home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / misc / volume25 / pclcomp / part01 next >
Encoding:
Text File  |  1991-11-03  |  55.3 KB  |  2,342 lines
  1. Newsgroups: comp.sources.misc
  2. From: tony@sdd.hp.com (Tony Parkhurst)
  3. Subject:  v25i010:  pclcomp - HP-PCL Compression Filter, Part01/02
  4. Message-ID: <csm-v25i010=pclcomp.173706@sparky.IMD.Sterling.COM>
  5. X-Md4-Signature: 2d1030bb05a81a220a089fb190e69865
  6. Date: Sun, 3 Nov 1991 23:37:34 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: tony@sdd.hp.com (Tony Parkhurst)
  10. Posting-number: Volume 25, Issue 10
  11. Archive-name: pclcomp/part01
  12. Environment: LaserJet
  13. Supersedes: pclcomp: Volume 19, Issue 13-14
  14.  
  15. Here is the latest version of pclcomp.  Improvements are basically related
  16. to bug fixes, supporting obsolete (but highly used) escape sequences, and
  17. a new and improved Mode 2 compression routine.
  18.  
  19. -- Tony Parkhurst    (tony@sdd.hp.com)
  20.  
  21. #!/bin/sh
  22. # This is a shell archive (produced by shar 3.49)
  23. # To extract the files from this archive, save it to a file, remove
  24. # everything above the "!/bin/sh" line above, and type "sh file_name".
  25. #
  26. # existing files will NOT be overwritten unless -c is specified
  27. #
  28. # This is part 1 of a multipart archive                                    
  29. # do not concatenate these parts, unpack them in order with /bin/sh        
  30. #
  31. # This shar contains:
  32. # length  mode       name
  33. # ------ ---------- ------------------------------------------
  34. #   1508 -rw-rw-r-- README
  35. #   1431 -r--r--r-- getopt.c
  36. #   3851 -r--r--r-- pclcomp.1
  37. #  64599 -r--r--r-- pclcomp.c
  38. #   4059 -rw-rw-r-- pclcomp.man
  39. #    415 -rw-rw-r-- printer.note
  40. #
  41. if test -r _shar_seq_.tmp; then
  42.     echo 'Must unpack archives in sequence!'
  43.     echo Please unpack part `cat _shar_seq_.tmp` next
  44.     exit 1
  45. fi
  46. # ============= README ==============
  47. if test -f 'README' -a X"$1" != X"-c"; then
  48.     echo 'x - skipping README (File already exists)'
  49.     rm -f _shar_wnt_.tmp
  50. else
  51. > _shar_wnt_.tmp
  52. echo 'x - extracting README (Text)'
  53. sed 's/^X//' << 'SHAR_EOF' > 'README' &&
  54. X
  55. X
  56. X     This is pclcomp -- An HP-PCL compression filter.  It reads in
  57. PCL graphics files, and outputs compressed PCL files which may be sent
  58. directly to printers that support the compressions.  A partial list of
  59. printer support is included.
  60. X
  61. X     Why use pclcomp?
  62. X
  63. X    1)  PCL files are much smaller ( up to 90% ).
  64. X
  65. X    2)  Graphics printing on a LaserJet (IIP or III) is faster.
  66. X
  67. X
  68. X     If you have a LaserJet II that does not support compression, you can
  69. still compress the files for storage, and decompress them while printing.
  70. X
  71. X     I wrote this program for testing.  This is NOT an HP product.  It will
  72. NOT be supported by HP, but rather myself, in my spare time, if need be.
  73. X
  74. X     If you need real support for driver development, then call Hewlett-
  75. Packard directly, preferably the ISV support group at the Boise Division.
  76. X
  77. X     You may use parts of this code within your drivers to support compression
  78. if you wish.
  79. X
  80. X     I did what I think is a reasonable job to make the program work for
  81. most possible PCL files.  Please feel free to send comments, complaints 
  82. or suggestions to me at tony@sdd.hp.com.  If you have a file that does
  83. not survive the filter intact, please e-mail me the file and describe the
  84. problem.
  85. X
  86. X     You will have to provide a getopt() function.
  87. This filter runs under UNIX and MS-DOS and hopefully anything else that
  88. supports ANSI-C.  To compile under HP-UX:
  89. X
  90. cc -Aa -O pclcomp.c -o pclcomp
  91. X
  92. X
  93. X     Please direct all compliments and praise to:  tony@sdd.hp.com
  94. X
  95. X     -- Tony Parkhurst
  96. X
  97. X
  98. SHAR_EOF
  99. chmod 0664 README ||
  100. echo 'restore of README failed'
  101. Wc_c="`wc -c < 'README'`"
  102. test 1508 -eq "$Wc_c" ||
  103.     echo 'README: original size 1508, current size' "$Wc_c"
  104. rm -f _shar_wnt_.tmp
  105. fi
  106. # ============= getopt.c ==============
  107. if test -f 'getopt.c' -a X"$1" != X"-c"; then
  108.     echo 'x - skipping getopt.c (File already exists)'
  109.     rm -f _shar_wnt_.tmp
  110. else
  111. > _shar_wnt_.tmp
  112. echo 'x - extracting getopt.c (Text)'
  113. sed 's/^X//' << 'SHAR_EOF' > 'getopt.c' &&
  114. #include <stdio.h>
  115. X
  116. #define index strchr
  117. X
  118. /*
  119. X * get option letter from argument vector
  120. X */
  121. int    opterr = 1,        /* useless, never set or used */
  122. X    optind = 1,        /* index into parent argv vector */
  123. X    optopt;            /* character checked for validity */
  124. char    *optarg;        /* argument associated with option */
  125. X
  126. #define BADCH    (int)'?'
  127. #define EMSG    ""
  128. #define tell(s)    fputs(*nargv,stderr);fputs(s,stderr); \
  129. X        fputc(optopt,stderr);fputc('\n',stderr);return(BADCH);
  130. X
  131. getopt(nargc,nargv,ostr)
  132. int    nargc;
  133. char    **nargv,
  134. X    *ostr;
  135. {
  136. X    static char    *place = EMSG;    /* option letter processing */
  137. X    register char    *oli;        /* option letter list index */
  138. X    char    *index();
  139. X
  140. X    if(!*place) {            /* update scanning pointer */
  141. X        if(optind >= nargc || *(place = nargv[optind]) != '-' || !*++place) return(EOF);
  142. X        if (*place == '-') {    /* found "--" */
  143. X            ++optind;
  144. X            return(EOF);
  145. X        }
  146. X    }                /* option letter okay? */
  147. X    if ((optopt = (int)*place++) == (int)':' || !(oli = index(ostr,optopt))) {
  148. X        if(!*place) ++optind;
  149. X        tell(": illegal option -- ");
  150. X    }
  151. X    if (*++oli != ':') {        /* don't need argument */
  152. X        optarg = NULL;
  153. X        if (!*place) ++optind;
  154. X    }
  155. X    else {                /* need an argument */
  156. X        if (*place) optarg = place;    /* no white space */
  157. X        else if (nargc <= ++optind) {    /* no arg */
  158. X            place = EMSG;
  159. X            tell(": option requires an argument -- ");
  160. X        }
  161. X         else optarg = nargv[optind];    /* white space */
  162. X        place = EMSG;
  163. X        ++optind;
  164. X    }
  165. X    return(optopt);            /* dump back option letter */
  166. }
  167. X
  168. X
  169. X
  170. SHAR_EOF
  171. chmod 0444 getopt.c ||
  172. echo 'restore of getopt.c failed'
  173. Wc_c="`wc -c < 'getopt.c'`"
  174. test 1431 -eq "$Wc_c" ||
  175.     echo 'getopt.c: original size 1431, current size' "$Wc_c"
  176. rm -f _shar_wnt_.tmp
  177. fi
  178. # ============= pclcomp.1 ==============
  179. if test -f 'pclcomp.1' -a X"$1" != X"-c"; then
  180.     echo 'x - skipping pclcomp.1 (File already exists)'
  181.     rm -f _shar_wnt_.tmp
  182. else
  183. > _shar_wnt_.tmp
  184. echo 'x - extracting pclcomp.1 (Text)'
  185. sed 's/^X//' << 'SHAR_EOF' > 'pclcomp.1' &&
  186. .TH PCLCOMP 1
  187. .SH NAME
  188. pclcomp \- Compress PCL graphics files.
  189. .SH SYNOPSIS
  190. .B pclcomp
  191. [
  192. .B "-0123drsvxz"
  193. ]
  194. [
  195. .B "-n"
  196. .I num
  197. ]
  198. [
  199. .I inputfile
  200. [
  201. .I outputfile
  202. ]]
  203. .br
  204. .SH DESCRIPTION
  205. .PP
  206. .B Pclcomp
  207. compresses (or decompresses) HP-PCL (Printer Control Language) graphics data.
  208. The supported compression modes are 0 (uncompressed), 1, 2 and 3.
  209. .B Pclcomp
  210. will read files using any of the modes 0 through 3, and will output using the
  211. modes which will give the best compression.  This compressed version of
  212. the file may be sent directly to a PCL compatible printer, thus reducing
  213. I/O bandwidth.  Pictures may also be saved in compressed form, reducing
  214. disk usage.
  215. In addition, PCL "imaging" files for the PaintJet XL are also supported.
  216. .PP
  217. The options to
  218. .B pclcomp
  219. control the compression modes.  By default,
  220. .B pclcomp
  221. will use modes 0, 2 and 3, but the user may restrict which output
  222. modes it uses by specifying them on the command line with the
  223. .B -0,
  224. .B -1,
  225. .B -2
  226. and
  227. .B -3
  228. options.  To decompress a file, simply specify
  229. .B -0
  230. as the only mode to use for output.  Mode 0 (
  231. .B -0
  232. ) should always be allowed since modes 1, 2 and 3 cannot be guaranteed to
  233. be better than mode 0 for all types of pictures.
  234. .PP
  235. The
  236. .B -z
  237. option disables the zero "strip" feature.  Since most printers do 
  238. zero "filling",
  239. .B pclcomp,
  240. by default, "strips" the trailing zeros of each row (or plane) of data.
  241. Some printers or programs may require that zero "stripping" be disabled.
  242. .PP
  243. By default,
  244. .B pclcomp
  245. expects the input raster width to be 2400 pixels (8" at 300 dpi), and if it is
  246. different (e.g. PaintJet), then the raster width should be specified by
  247. the Source Raster Width escape sequence
  248. .I <esc*r#S>.
  249. However, many applications do not set the width and assume a default, therefore,
  250. the user may use the 
  251. .B -n
  252. option to
  253. .B pclcomp
  254. to specify a new default raster width.  For PaintJet (8" at 180 dpi), the
  255. number should be 1440.  If the PCL file contains the Source Raster Width
  256. escape sequence, it will override this default.  If
  257. .B pclcomp
  258. thinks that more data is coming in than the specified width, it will
  259. generate a warning, and continue processing (and perhaps truncating) data.
  260. .PP
  261. The
  262. .B -x
  263. option will cause
  264. .B pclcomp
  265. to remove any horizontal offset sequences from the data.  Only use this
  266. option if white is defined to be zero (as with LaserJets).  This will
  267. shrink the data more if modes 2 or 3 are used.
  268. .PP
  269. The
  270. .B -r
  271. option causes
  272. .B pclcomp
  273. to append a
  274. reset sequence
  275. .I "(<esc>E)"
  276. to the end of the job.
  277. .PP
  278. Use the
  279. .B "-d"
  280. option to
  281. .B pclcomp
  282. if the output is to be sent to a DeskJet printer.
  283. .PP
  284. Some applications erroneously send
  285. .I "<esc>*rB"
  286. and
  287. .I "<esc>*rA"
  288. sequences between every row of graphics data.  The 
  289. .B -s
  290. option to
  291. .B pclcomp
  292. will "strip" all 
  293. .I "<esc>*rB"
  294. sequences, and all
  295. .I "<esc>*rA"
  296. sequences after the first occurrence of this sequence.  
  297. In addition, text and control characters residing between
  298. .I "<esc>*rA"
  299. and
  300. .I "<esc>*rB"
  301. sequences will be discarded.
  302. While this will work
  303. well
  304. for many jobs, it may have problems on multi-page or complex jobs.
  305. .PP
  306. The
  307. .B -v
  308. option simply gives statistics to
  309. .I stderr
  310. about which compression modes were used.
  311. .SH EXAMPLES
  312. .nf
  313. To compress a PCL file for LaserJet III, use:
  314. X    pclcomp infile outfile
  315. X
  316. To compress a PCL file for the PaintJet (A size page at 180 dpi), use:
  317. X    pclcomp -01 -n 1440 infile outfile
  318. X
  319. To compress a PCL file for DeskJet, use:
  320. X    pclcomp -d012 infile outfile
  321. X
  322. To fully decompress a PCL file, use:
  323. X    pclcomp -0z < infile > outfile
  324. .fi
  325. .SH WARNINGS
  326. .PP
  327. The 
  328. .B -z
  329. option can cause the output to be larger than the input.
  330. .PP
  331. The 
  332. .B -s
  333. option is useful, but it can cause erroneous output.
  334. .PP
  335. The
  336. .B -x
  337. option can cause black areas on the left side of the picture on color
  338. printers.
  339. .SH AUTHOR
  340. Tony Parkhurst, Hewlett-Packard, San Diego Division  (tony@sdd.hp.com)
  341. SHAR_EOF
  342. chmod 0444 pclcomp.1 ||
  343. echo 'restore of pclcomp.1 failed'
  344. Wc_c="`wc -c < 'pclcomp.1'`"
  345. test 3851 -eq "$Wc_c" ||
  346.     echo 'pclcomp.1: original size 3851, current size' "$Wc_c"
  347. rm -f _shar_wnt_.tmp
  348. fi
  349. # ============= pclcomp.c ==============
  350. if test -f 'pclcomp.c' -a X"$1" != X"-c"; then
  351.     echo 'x - skipping pclcomp.c (File already exists)'
  352.     rm -f _shar_wnt_.tmp
  353. else
  354. > _shar_wnt_.tmp
  355. echo 'x - extracting pclcomp.c (Text)'
  356. sed 's/^X//' << 'SHAR_EOF' > 'pclcomp.c' &&
  357. /*
  358. **  Pclcomp -- PCL compression filter.
  359. **
  360. **  If you have any problems or errors to report, please send them to me:
  361. **
  362. **  Tony Parkhurst  
  363. ** 
  364. **  Email address:  tony@sdd.hp.com    -or-   hp-sdd!tony
  365. **
  366. **  Please send a copy of the file that is causing the problem, and the
  367. **  version of pclcomp you are using.
  368. **
  369. **  All suggestions and requests are welcome.
  370. */
  371. X
  372. /*
  373. X ***************************************************************************
  374. X *
  375. X * $Source: /disc/44/cgtriton/tony/filters/pclcomp/RCS/pclcomp.c,v $ 
  376. X * $Date: 91/09/13 13:56:28 $ 
  377. X * $Revision: 1.39 $
  378. X *
  379. X * Description:    Compresses pcl graphics files.
  380. X *
  381. X * Author:       Tony Parkhurst
  382. X * Created:      890427
  383. X * Language:     C
  384. X *
  385. X * (c) Copyright 1989, Hewlett-Packard Company, all rights reserved.
  386. X *
  387. X ***************************************************************************
  388. X */
  389. X
  390. X
  391. /*
  392. X ***************************************************************************
  393. X *
  394. X * $Log:    pclcomp.c,v $
  395. X * Revision 1.39  91/09/13  13:56:28  13:56:28  tony (Tony Parkhurst)
  396. X * Added code to disable zerostrip in mode 2.
  397. X * 
  398. X * Revision 1.38  91/09/10  15:47:28  15:47:28  tony (Tony Parkhurst)
  399. X * Added include file for isdigit()
  400. X * 
  401. X * Revision 1.37  91/09/10  15:08:23  15:08:23  tony (Tony Parkhurst)
  402. X * Clamped horizontal offsets to raster widths.
  403. X * 
  404. X * Revision 1.36  91/09/10  15:04:15  15:04:15  tony (Tony Parkhurst)
  405. X * Re-vamped fraction parsing.
  406. X * 
  407. X * Revision 1.35  91/09/10  14:03:40  14:03:40  tony (Tony Parkhurst)
  408. X * Fixed potential problem with fractions.
  409. X * Removed obsolete invert flag.
  410. X * Cleaned up some comments.
  411. X * 
  412. X * Revision 1.34  91/09/10  13:21:48  13:21:48  tony (Tony Parkhurst)
  413. X * Fixed problems with data gaps  (0W instead of 0V0V0W)
  414. X * Fixed problems with horizontal offsets and mode 3 compression.
  415. X * Added option to strip horizontal offsets (zero value must be white).
  416. X * 
  417. X * Revision 1.33  91/07/18  15:18:43  15:18:43  tony (Tony Parkhurst)
  418. X * Replaced mode 2 compression routine.  Works better now.
  419. X * 
  420. X * Revision 1.32  91/07/08  11:27:24  11:27:24  tony (Tony Parkhurst)
  421. X * Enhanced the strip algorithm for merged graphics.
  422. X * (Also cleaned up some comments, couple of statements.)
  423. X * 
  424. X * Revision 1.31  91/05/30  15:18:51  15:18:51  tony (Tony Parkhurst)
  425. X * Oops, fixed it right this time.
  426. X * 
  427. X * Revision 1.30  91/05/30  15:06:20  15:06:20  tony (Tony Parkhurst)
  428. X * Added fix for negative value for <esc>*r#U.
  429. X * 
  430. X * Revision 1.29  91/05/03  10:12:30  10:12:30  tony (Tony Parkhurst)
  431. X * Small changes.
  432. X * 
  433. X * Revision 1.28  91/04/30  09:41:24  09:41:24  tony (Tony Parkhurst)
  434. X * Now puts stdin and stdout in binary mode for MSDOS.
  435. X *     Changes courtesy of Mike Slomin.
  436. X * Changed usage message a bit.
  437. X * 
  438. X * Revision 1.27  91/04/23  15:48:05  15:48:05  tony (Tony Parkhurst)
  439. X * Added handling of plus_sign in value fields.
  440. X * 
  441. X * Revision 1.26  91/04/23  09:47:11  09:47:11  tony (Tony Parkhurst)
  442. X * Pass thru unknown modes.
  443. X * 
  444. X * Revision 1.25  91/04/18  11:09:27  11:09:27  tony (Tony Parkhurst)
  445. X * Added parse for fractions in values (i.e. <esc>(s16.67H)
  446. X * 
  447. X * Revision 1.24  91/04/10  14:16:30  14:16:30  tony (Tony Parkhurst)
  448. X * strips text and control codes between <esc>*rA and <esc>*rB w/ -s option
  449. X * 
  450. X * Revision 1.23  91/04/05  14:53:25  14:53:25  tony (Tony Parkhurst)
  451. X * Added fixed for deskjet
  452. X * Also added a stripping feature.
  453. X * 
  454. X * Revision 1.22  91/04/05  08:48:53  08:48:53  tony (Tony Parkhurst)
  455. X * Added some error checkin on output for MS-DOS users.
  456. X * 
  457. X * Revision 1.21  91/04/04  12:53:32  12:53:32  tony (Tony Parkhurst)
  458. X * Replaced parser.
  459. X *    Now handles combined escape sequences.
  460. X *    Now handles downloads.
  461. X *    Now combines mode changes with data.
  462. X * 
  463. X * Revision 1.20  91/04/04  08:02:12  08:02:12  tony (Tony Parkhurst)
  464. X * Removed some test code.
  465. X * 
  466. X * Revision 1.19  91/03/25  14:38:48  14:38:48  tony (Tony Parkhurst)
  467. X * Changed defaults.
  468. X * 
  469. X * Revision 1.18  91/03/25  14:31:22  14:31:22  tony (Tony Parkhurst)
  470. X * Re-worked memory allocation stuff for funky input files.
  471. X * 
  472. X * Revision 1.17  91/03/25  13:50:19  13:50:19  tony (Tony Parkhurst)
  473. X * Use command line args for file w/o -i or -o.
  474. X * 
  475. X * Revision 1.16  91/03/04  14:23:15  14:23:15  tony (Tony Parkhurst)
  476. X * Fixed to allow ONLY mode 3 if the user really wants it.
  477. X * 
  478. X * Revision 1.15  91/03/04  14:08:23  14:08:23  tony (Tony Parkhurst)
  479. X * Added an exit(0) at the end of main.
  480. X * fixed up some zerostrip stuff.
  481. X * made mode 3 the highest priority mode.
  482. X * 
  483. X * Revision 1.14  91/02/20  13:57:27  13:57:27  tony (Tony Parkhurst)
  484. X * Changed priority a bit.
  485. X * Added some zerostripping for mode 2.
  486. X * 
  487. X * Revision 1.13  91/02/06  15:31:00  15:31:00  tony (Tony Parkhurst)
  488. X * oops.
  489. X * 
  490. X * Revision 1.12  91/02/06  14:41:28  14:41:28  tony (Tony Parkhurst)
  491. X * fixed usage message
  492. X * 
  493. X * Revision 1.11  91/02/06  14:38:10  14:38:10  tony (Tony Parkhurst)
  494. X * Added file input and output for MS-DOS.
  495. X * 
  496. X * Revision 1.10  91/02/05  17:49:23  17:49:23  tony (Tony Parkhurst)
  497. X * Fixed problem with zero stripped input.
  498. X * 
  499. X * Revision 1.9  91/02/05  16:11:39  16:11:39  tony (Tony Parkhurst)
  500. X * Removed delay code and bitfield stuff.
  501. X * 
  502. X * Revision 1.8  91/02/05  11:04:53  11:04:53  tony (Tony Parkhurst)
  503. X * Added io delay stuff for testing.
  504. X * 
  505. X * Revision 1.7  91/02/05  10:28:32  10:28:32  tony (Tony Parkhurst)
  506. X * Fix for someone specifing ONLY mode 3.
  507. X * 
  508. X * Revision 1.6  91/01/29  14:13:09  14:13:09  tony (Tony Parkhurst)
  509. X * Updated some comments.
  510. X * 
  511. X * Revision 1.5  91/01/29  13:26:24  13:26:24  tony (Tony Parkhurst)
  512. X * Cleaned up, revamped a bit.
  513. X * 
  514. X * Revision 1.4  89/11/09  15:59:16  15:59:16  tony (Tony Parkhurst)
  515. X * Fix for esc * r U coming after esc * r A.
  516. X * 
  517. X * Revision 1.3  89/10/24  11:31:12  11:31:12  tony (Tony Parkhurst)
  518. X * Added parsing of <esc>*rC
  519. X * 
  520. X * Revision 1.2  89/10/13  09:56:46  09:56:46  tony (Tony Parkhurst)
  521. X * Completely revamped by Greg G.
  522. X * 
  523. X * Revision 1.1  89/06/15  13:57:46  13:57:46  tony (Tony Parkhurst)
  524. X * Initial revision
  525. X * 
  526. X *
  527. X ***************************************************************************
  528. X */
  529. X 
  530. static const char copyr[]=
  531. X    "Copyright (c) 1991, Hewlett-Packard Company, all rights reserved.";
  532. X
  533. static const char author[]="Tony Parkhurst";
  534. X
  535. static const char rcs_id[]="$Header: pclcomp.c,v 1.39 91/09/13 13:56:28 tony Exp $";
  536. X
  537. static const char rev_id[]="$Revision: 1.39 $";
  538. X 
  539. X
  540. /*
  541. X *   This program was first a filter by Dean to compress pcl graphics.
  542. X *
  543. X *   This program now will do optimal compression using modes 0,1,2 and 3
  544. X *
  545. X *   Also, this program will take compressed input.
  546. X *
  547. X *   Input and output formats are standard pcl.
  548. X *
  549. X *   Imaging files ("Configure Image Data") are supported.
  550. X *
  551. X *   Pclcomp does not take advantage of Y-Offset for blank areas.  
  552. X *   This is because Y-Offset creates white areas, but we don't do enough
  553. X *   parsing to determine what value "white" has.  An application that
  554. X *   can assume white values could make use of this sequence.
  555. X *
  556. X *   Pclcomp does not do any of the block compression modes (4-8).
  557. X *
  558. X *   An additional enhancement would be to compare all the planes in a
  559. X *   multi-plane file (color) and if nothing changed, using mode 3, just
  560. X *   output a single <esc>*b0W.
  561. X *
  562. X *
  563. X *   Usage:  pclcomp [-v] [-0] [-1] [-2] [-3] [-z] [-n###] < infile > outfile
  564. X *
  565. X *   Pclcomp will do graphics compression based on compression modes 0, 1, 2
  566. X *   and 3.  (Mode 0 is uncompressed).  Pclcomp will accept all modes, and
  567. X *   will attempt to optimize by selecting the best output mode for each
  568. X *   row (or plane) of data.  By default, pclcomp will use all 4 modes, but
  569. X *   the user may restrict which output modes to use with the -0123 options.
  570. X *   For example, to use pclcomp for output to a PaintJet which only knows
  571. X *   modes 0 and 1 (the XL also understands modes 2 and 3), one would use:
  572. X *
  573. X *      pclcomp -01 < infile > outfile
  574. X *
  575. X *   Note:  Mode 0 should always be allowed.  None of the other modes is
  576. X *   guaranteed to be better than mode 0 in all cases.
  577. X *
  578. X *   The 'v' option tells the number of rows (planes) of data input and output
  579. X *   in the different modes (to stderr).
  580. X *
  581. X *   By default, pclcomp does zero "stripping" which is useful for PaintJet 
  582. X *   files using only modes 0 and 1, the PaintJet (and other PCL printers) 
  583. X *   will do zero "filling".  
  584. X *   NOTE: Use the 'z' option to disable zero stripping.
  585. X *
  586. X *   The 'n' option is to change the default number of pixels in a picture.
  587. X *   The proper way to set the pixel width is with the source raster width
  588. X *   sequence <esc*r#S>, but soo many applications just assume the default,
  589. X *   which is different on different printers, so I am providing this
  590. X *   command line option to set a new default.  One could also change the
  591. X *   DEFAULT constant below (make sure it is a multiple of 8).  
  592. X *   Currently it is set to 8" at 300 dpi (2400).
  593. X */
  594. X
  595. #include <stdio.h>
  596. #include <string.h>
  597. #include <ctype.h>
  598. X
  599. #ifdef MSDOS
  600. #include <fcntl.h>
  601. #endif
  602. X
  603. X
  604. /* This flag is for code that uses bitfields for 68000 systems */
  605. /* Not recommended at this time */
  606. X
  607. #define BITFIELDS 0
  608. X
  609. #define Get_Character() getchar()
  610. X
  611. #define MIN(x,y)    ( ((x) < (y)) ? (x) : (y) )
  612. X
  613. #define TRUE 1
  614. #define FALSE 0
  615. X
  616. #define ESC    27
  617. X
  618. #define DEFAULT 2400        /* default width in pixels (multiple of 8) */
  619. X
  620. #define MAXMODES  4
  621. #define MAXPLANES 8
  622. #define MAXBYTES 60000        /* now mostly meaningless, just a big number */
  623. X
  624. unsigned char    *seed_row[MAXPLANES];
  625. unsigned char    *new_row;
  626. unsigned char    *out_row[MAXMODES];
  627. unsigned int    out_size[MAXMODES];
  628. X
  629. char    memflag = FALSE;    /* set when memory has been allocated */
  630. X
  631. X
  632. char    mode0=FALSE,
  633. X    mode1=FALSE,
  634. X    mode2=FALSE,
  635. X    mode3=FALSE;
  636. X
  637. unsigned char    num_planes=1;
  638. unsigned char    curr_plane=0;
  639. X
  640. char    imaging = FALSE;        /* not imaging, so no lockout */
  641. X
  642. char    verbose = FALSE;
  643. X
  644. unsigned char    inmode = 0;        /* input compression mode */
  645. unsigned char    outmode = 0;        /* output compression mode */
  646. X
  647. unsigned int    rasterwidth=DEFAULT/8;    /* width of picture, in bytes */
  648. unsigned int    rpix = DEFAULT;        /* width of picture, in pixels */
  649. X
  650. unsigned char    zerostrip= TRUE;    /* strip trailing zeros */
  651. X
  652. unsigned int    inuse[4]={0,0,0,0}, outuse[4] = {0,0,0,0};
  653. X
  654. char    widthwarning = FALSE;    /* for trucation warning */
  655. char    firstrow = TRUE;    /* to prevent mode 3 from being first */
  656. X
  657. X
  658. struct {            /* this will hold the data for the  */
  659. X     unsigned char model;    /* configuring of image processing   */
  660. X     unsigned char pix_mode;
  661. X     unsigned char inx_bits;
  662. X     unsigned char red;
  663. X     unsigned char green;
  664. X     unsigned char blue;
  665. X     short wr;
  666. X     short wg;
  667. X     short wb;
  668. X     short br;
  669. X     short bg;
  670. X     short bb; 
  671. } imdata;
  672. X
  673. extern    unsigned char *malloc();
  674. X
  675. char    *filein = NULL, *fileout = NULL;
  676. X
  677. /*
  678. **  These variables are for the new parser.
  679. **  The new parser handles more sequences, and also deals with combined
  680. **  escape sequences better.
  681. */
  682. X
  683. int    parameter;
  684. int    group_char;
  685. int    terminator;
  686. int    old_terminator;
  687. int    value;
  688. float    fvalue;            /* fractional value */
  689. int    scanf_count;
  690. char    in_sequence = FALSE;
  691. char    pass_seq;
  692. char    plus_sign;        /* for relative values */
  693. X
  694. X
  695. /* dummy buffer */
  696. char buf[BUFSIZ];
  697. X
  698. /*
  699. **  If the printer is a DeskJet, then we must handle <esc>*rB differently
  700. **  Option '-d' will turn on this mode.
  701. */
  702. X
  703. char    deskjet = FALSE;
  704. X
  705. X
  706. /*
  707. **  Many drivers it seems put <esc>*rB<esc>*rA between each and every row
  708. **  of data.  This defeats compression mode 3 on a DeskJet, and also
  709. **  makes the PaintJet (not XL) quite slow.  This next flag "-s" on the
  710. **  command line, will attempt to do a reasonable job of stripping
  711. **  out the excess commands.
  712. **
  713. **  The in_graphics flag will be used to strip unwanted control chars from
  714. **  the file.
  715. */
  716. X
  717. char    strip_seq = FALSE;
  718. char    in_graphics = FALSE;
  719. X
  720. X
  721. /*
  722. **  Just for certain special cases, it would be nice to append an <esc>E reset
  723. **  to the end of the job.  Specify with "-r".
  724. */
  725. X
  726. char    reset_seq = FALSE;
  727. X
  728. X
  729. char    *progname;        /* to hold the program name for verbose */
  730. X
  731. /*
  732. **  Even though the horizontal offset command <esc>*b#X is obsolete, many
  733. **  drivers still use it, and it causes some interesting problems with
  734. **  mode 3 compression, so pclcomp needs to deal with it in some hopefully
  735. **  intelligent fashion, and they will get stripped if -x is used.
  736. */
  737. X
  738. int    horiz_offset = 0;
  739. X
  740. char    strip_offsets = FALSE;
  741. X
  742. X
  743. static float    Get_Frac();    /* instead of scanf */
  744. X
  745. X
  746. X
  747. /*
  748. ******************************************************************************
  749. **
  750. **                Main program.
  751. **
  752. ******************************************************************************
  753. */
  754. X
  755. main(argc, argv)
  756. int argc;
  757. char *argv[];
  758. {
  759. X  int    c,j;
  760. X  extern char *optarg;
  761. X  extern int   optind;
  762. X
  763. X    progname = argv[0];
  764. X
  765. #ifdef MSDOS
  766. X    setmode(fileno(stdin), O_BINARY);    /* Place stdin and stdout in */
  767. X    setmode(fileno(stdout), O_BINARY);    /* binary mode. (Mike Slomin)*/
  768. #endif
  769. X
  770. X    /* parse up the args here */
  771. X
  772. X  while ((c = getopt(argc, argv, "0123drsvzn:i:o:sx")) != EOF )
  773. X    switch(c){
  774. X    case '0':
  775. X            mode0 = TRUE;
  776. X            break;
  777. X    case '1':
  778. X            mode1 = TRUE;
  779. X            break;
  780. X    case '2':
  781. X            mode2 = TRUE;
  782. X            break;
  783. X    case '3':
  784. X            mode3 = TRUE;
  785. X            break;
  786. X    case 'd':
  787. X            deskjet = TRUE;
  788. X            break;
  789. X    case 'r':
  790. X            reset_seq = TRUE;
  791. X            break;
  792. X    case 's':
  793. X            strip_seq = TRUE;
  794. X            break;
  795. X    case 'v':
  796. X            verbose = TRUE;
  797. X            break;
  798. X    case 'x':
  799. X            strip_offsets = TRUE;
  800. X            break;
  801. X    case 'z':
  802. X            zerostrip = FALSE;
  803. X            break;
  804. X    case 'n':
  805. X            rpix = atoi(optarg);    /* new default */
  806. X            rasterwidth = (rpix + 7) / 8;    /* round up */
  807. X            break;
  808. X
  809. X    case 'i':
  810. X            filein = optarg;
  811. X            break;
  812. X    case 'o':
  813. X            fileout = optarg;
  814. X            break;
  815. X
  816. X    case '?':
  817. X    default:
  818. X            fprintf(stderr, 
  819. X            "Usage: %s [-0123drsvxz] [-n###] [infile [outfile]]\n",
  820. X                argv[0]);
  821. X            exit(-1);
  822. X    };
  823. X
  824. X    if ( verbose )
  825. X    {
  826. X        fprintf(stderr, "%s: %s\n", argv[0], rev_id);
  827. X    }
  828. X
  829. X
  830. X  if ( ! ( mode0 || mode1 || mode2 || mode3) )    /* any modes on? */
  831. X    mode0 = /* mode1 = */ mode2 = mode3 = TRUE;    /* 3 modes by default */
  832. X
  833. X    /*
  834. X    **  Check to see if any file args were given on the command line.
  835. X    **  Ones that were not preceded by a "-i" or "-o".
  836. X    */
  837. X
  838. X    if ( filein == NULL && optind < argc && argv[optind] != NULL )
  839. X        filein = argv[optind++];
  840. X
  841. X    if ( fileout == NULL && optind < argc && argv[optind] != NULL )
  842. X        fileout = argv[optind++];
  843. X
  844. X    /*
  845. X    **  Now open files for stdin and stdout if provided by the user.
  846. X    */
  847. X
  848. X    if ( filein != NULL )        /* new input file */
  849. X
  850. X        if ( freopen( filein, "rb", stdin ) == NULL )
  851. X        {
  852. X            fprintf(stderr,"Unable to open %s for input.\n",filein);
  853. X            exit(-42);
  854. X        }
  855. X
  856. X    if ( fileout != NULL )        /* new output file */
  857. X
  858. X        if ( freopen( fileout, "wb", stdout ) == NULL )
  859. X        {
  860. X            fprintf(stderr, "Unable to open %s for output.\n",
  861. X                fileout);
  862. X            exit(-43);
  863. X        }
  864. X
  865. X
  866. X    /*
  867. X    **
  868. X    **        This is the pcl input parsing loop.
  869. X    **
  870. X    */
  871. X
  872. X    while( ( c = getchar() ) != EOF )
  873. X    {
  874. X
  875. X        /*  Ignore all chars until an escape char  */
  876. X
  877. X        /*
  878. X        **  If we are in graphics, toss it if strip_seq is set.
  879. X        */
  880. X
  881. X        if ( c != ESC )
  882. X        {
  883. X            if ( !strip_seq || !in_graphics )
  884. X                putchar(c);    /* pass it thru */
  885. X
  886. X            continue;    /* pop to the top of the loop */
  887. X        }
  888. X
  889. X        /*
  890. X        **  Now we have an escape sequence, get the parameter char.
  891. X        */
  892. X
  893. X        parameter = getchar();
  894. X
  895. X        if ( parameter == EOF )        /* oops */
  896. X        {
  897. X            putchar ( ESC );
  898. X            fprintf(stderr, "Warning:  File ended with <esc>.\n");
  899. X            break;            /* unexpected end of input */
  900. X        }
  901. X
  902. X        /*
  903. X        **  Now check to see if it is a two character sequence.
  904. X        */
  905. X
  906. X        if ( parameter >= '0' && parameter <= '~' )
  907. X        {
  908. X            putchar ( ESC );
  909. X            putchar ( parameter );        /* pass it thru */
  910. X
  911. X            /*
  912. X            **  If the second character is an E, then we
  913. X            **  and the printer do a reset.
  914. X            */
  915. X
  916. X            if ( parameter == 'E' )
  917. X            {
  918. X                free_mem();
  919. X                curr_plane = 0;
  920. X                num_planes = 1;
  921. X                imaging = FALSE;
  922. X                inmode = 0;
  923. X                outmode = 0;
  924. X                in_graphics = FALSE;
  925. X
  926. X                /* can't do this if user gave value with -n.
  927. X                rasterwidth = DEFAULT/8;
  928. X                rpix = DEFAULT;
  929. X                */
  930. X            }
  931. X
  932. X            continue;        /* return to the top */
  933. X        }
  934. X
  935. X        /*
  936. X        **  Now check to make sure that the parameter character is
  937. X        **  within range.
  938. X        */
  939. X
  940. X        if ( parameter < '!' || parameter > '/' )
  941. X        {
  942. X            putchar ( ESC );
  943. X            putchar ( parameter );
  944. X
  945. X            fprintf(stderr, "Warning:  Invalid escape sequence.\n");
  946. X
  947. X            continue;
  948. X        }
  949. X
  950. X        /*
  951. X        **  We are only interested in certain parameters, so pass
  952. X        **  the rest of the sequences.
  953. X        */
  954. X
  955. X        /*
  956. X        **  For the moment, we are only interested in '*' (graphics)
  957. X        **  '(' and ')' (downloads).  Although we do not do anything
  958. X        **  with downloads, we need to pass the binary data thru
  959. X        **  untouched.
  960. X        **  Oops, '&' is handled too.
  961. X        */
  962. X
  963. X        if ( parameter != '*' && parameter != '(' 
  964. X            && parameter != ')' && parameter != '&' )
  965. X        {
  966. X
  967. X            /*
  968. X            **  If the "stripper" is active, we need to suspend
  969. X            **  it till graphics are re-started.
  970. X            */
  971. X
  972. X            if ( strip_seq && !in_graphics )
  973. X            {
  974. X                curr_plane = 0;
  975. X                free_mem();        /* force re-start */
  976. X            }
  977. X
  978. X            /*
  979. X            **  Pass thru the sequence intact.
  980. X            */
  981. X
  982. X            putchar ( ESC );
  983. X            putchar ( parameter );
  984. X            Flush_To_Term();        /* flush rest of seq. */
  985. X            continue;
  986. X        }
  987. X
  988. X
  989. X        /*
  990. X        **  Parameter character is in range, look for a valid group char
  991. X        */
  992. X
  993. X        group_char = getchar();
  994. X
  995. X        if ( group_char == EOF )    /* oops, ran out of input */
  996. X        {
  997. X            putchar ( ESC );
  998. X            putchar ( parameter );
  999. X
  1000. X            fprintf(stderr, "Warning:  Incomplete escape sequence.\n");
  1001. X            break;
  1002. X        }
  1003. X
  1004. X        /*
  1005. X        **  See if in proper range.  If it isn't, it is not an error
  1006. X        **  because the group character is optional for some sequences.
  1007. X        **  For the moment, we are not interested in those sequences,
  1008. X        **  so pass them thru.
  1009. X        */
  1010. X
  1011. X        if ( group_char < '`' || group_char > '~' )
  1012. X        {
  1013. X
  1014. X            /*
  1015. X            **  If the "stripper" is active, we need to suspend
  1016. X            **  it till graphics are re-started.
  1017. X            */
  1018. X
  1019. X            if ( strip_seq && !in_graphics )
  1020. X            {
  1021. X                curr_plane = 0;
  1022. X                free_mem();        /* force re-start */
  1023. X            }
  1024. X
  1025. X            /*
  1026. X            **  Pass thru the sequence intact.
  1027. X            */
  1028. X
  1029. X            putchar ( ESC );
  1030. X            putchar ( parameter );
  1031. X            putchar ( group_char );
  1032. X            if ( group_char < '@' || group_char > '^' )
  1033. X                Flush_To_Term();    /* pass rest of seq. */
  1034. X            continue;
  1035. X        }
  1036. X
  1037. X        /*
  1038. X        **  Now we have a valid group character, decide if we want
  1039. X        **  to deal with this escape sequence.
  1040. X        **
  1041. X        **  Sequences we want do deal with include:
  1042. X        **
  1043. X        **    <esc>*r    ** graphics
  1044. X        **    <esc>*b    ** graphics
  1045. X        **    <esc>*v    ** graphics
  1046. X        **
  1047. X        **  Sequences we must pass thru binary data:
  1048. X        **
  1049. X        **    <esc>*c    ** pattern
  1050. X        **    <esc>*s    ** download dither
  1051. X        **    <esc>*t    ** obsolete
  1052. X        **    <esc>(f    ** download char set
  1053. X        **    <esc>(s    ** download char
  1054. X        **    <esc>)s    ** download font
  1055. X        **    <esc>&a    ** logical page
  1056. X        **    <esc>&l    ** obsolete
  1057. X        **
  1058. X        */
  1059. X
  1060. X        if (  ( parameter == '*'
  1061. X            && group_char != 'r' && group_char != 'b' 
  1062. X            && group_char != 'v' && group_char != 'c' 
  1063. X            && group_char != 't' && group_char != 's' )
  1064. X           || ( parameter == '&'
  1065. X            && group_char != 'a' && group_char != 'l' )
  1066. X           || ( parameter == '(' 
  1067. X            && group_char != 'f' && group_char != 's' )
  1068. X           || ( parameter == ')' && group_char != 's' ) )
  1069. X        {
  1070. X            /*
  1071. X            **  Definately not interested in the sequence.
  1072. X            */
  1073. X
  1074. X            /*
  1075. X            **  If the "stripper" is active, we need to suspend
  1076. X            **  it till graphics are re-started.
  1077. X            */
  1078. X
  1079. X            if ( strip_seq && !in_graphics )
  1080. X            {
  1081. X                curr_plane = 0;
  1082. X                free_mem();        /* force re-start */
  1083. X            }
  1084. X
  1085. X            /*
  1086. X            **  Pass thru the sequence intact.
  1087. X            */
  1088. X
  1089. X            putchar ( ESC );
  1090. X            putchar ( parameter );
  1091. X            putchar ( group_char );
  1092. X            Flush_To_Term();
  1093. X            continue;
  1094. X        }
  1095. X
  1096. X
  1097. X        /*
  1098. X        **  If the sequence is <esc>&a#H, it will have gotten past
  1099. X        **  the above, but we need to suspend the "stripper" if
  1100. X        **  it is active, because the CAP is getting moved.
  1101. X        **
  1102. X        **  The <esc>*p#X/Y sequences will have been filtered
  1103. X        **  thru just above (<esc>*p is not a needed group).
  1104. X        */
  1105. X
  1106. X        if ( strip_seq && parameter != '*' && !in_graphics )
  1107. X        {
  1108. X            curr_plane = 0;
  1109. X            free_mem();        /* force re-start */
  1110. X        }
  1111. X
  1112. X
  1113. X        /*
  1114. X        **  Now set up a pass thru flag so we can ignore the entire
  1115. X        **  sequences of some of these.
  1116. X        */
  1117. X
  1118. X        if ( parameter != '*' )
  1119. X            pass_seq = TRUE;
  1120. X
  1121. X        else if ( group_char == 'c' || group_char == 't' 
  1122. X               || group_char == 's' )
  1123. X
  1124. X            pass_seq = TRUE;
  1125. X        else
  1126. X            pass_seq = FALSE;
  1127. X
  1128. X
  1129. X        /*
  1130. X        **  Now we have a sequence that we are definately interested in.
  1131. X        **
  1132. X        **  Get the value field and terminator, and loop until final
  1133. X        **  terminator is found.
  1134. X        */
  1135. X
  1136. X        do
  1137. X        {
  1138. X            /* first see if the value has a plus sign */
  1139. X
  1140. X            scanf_count = scanf(" + %d", &value );
  1141. X
  1142. X            if ( scanf_count == 1 )
  1143. X
  1144. X                plus_sign = TRUE;
  1145. X            else
  1146. X            {
  1147. X                plus_sign = FALSE;
  1148. X
  1149. X                scanf_count = scanf(" %d", &value );
  1150. X
  1151. X                if ( scanf_count == 0 )
  1152. X                    value = 0;        /* by default */
  1153. X            }
  1154. X
  1155. X            /*
  1156. X            **  I wonder if I will get bitten by a trailing
  1157. X            **  space character right here?
  1158. X            */
  1159. X
  1160. X            terminator = getchar();
  1161. X
  1162. X            /*
  1163. X            **  Check for a fractional component.
  1164. X            */
  1165. X
  1166. X            fvalue = 0.0;
  1167. X
  1168. X            if ( terminator == '.' )
  1169. X            {
  1170. X                fvalue = Get_Frac();
  1171. X
  1172. X                /*
  1173. X                **  Now get real terminator.
  1174. X                */
  1175. X
  1176. X                terminator = getchar();
  1177. X            }
  1178. X
  1179. X
  1180. X            if ( terminator == EOF )    /* barf */
  1181. X            {
  1182. X                fprintf(stderr, 
  1183. X                "Warning:  Incomplete sequence at EOF.\n");
  1184. X                break;
  1185. X            }
  1186. X
  1187. X            /*
  1188. X            **  If the pass_seq flag is set, then just pass
  1189. X            **  it thru to stdout until a 'W' is found.
  1190. X            */
  1191. X
  1192. X            if ( pass_seq )
  1193. X            {
  1194. X                /*
  1195. X                **  If not in sequence, then we output esc
  1196. X                **  otherwise, output the saved terminator.
  1197. X                */
  1198. X
  1199. X                if ( !in_sequence )
  1200. X                {
  1201. X                    in_sequence = TRUE;
  1202. X                    putchar ( ESC );
  1203. X                    putchar ( parameter );
  1204. X                    putchar ( group_char );
  1205. X                } else
  1206. X                {
  1207. X                    putchar ( old_terminator );
  1208. X                }
  1209. X
  1210. X                /* now pass the value */
  1211. X
  1212. X                if ( plus_sign )
  1213. X                    putchar('+');
  1214. X
  1215. X                /*
  1216. X                **  See if there was a non-zero fraction.
  1217. X                */
  1218. X
  1219. X                if ( fvalue != 0.0 )
  1220. X                {
  1221. X                    if ( value < 0 )
  1222. X                    {
  1223. X                        putchar('-');
  1224. X                        value = -value;
  1225. X                    }
  1226. X
  1227. X                    fvalue += value;
  1228. X
  1229. X                    printf("%g", fvalue);
  1230. X
  1231. X                } else if ( scanf_count )
  1232. X                    printf("%0d", value);
  1233. X                
  1234. X                /*
  1235. X                **  We save the terminator, because we may
  1236. X                **  need to change it to upper case.
  1237. X                */
  1238. X
  1239. X                old_terminator = terminator;
  1240. X
  1241. X                /* if binary data, pass it thru */
  1242. X
  1243. X                if ( terminator == 'W' )    /* aha */
  1244. X                {
  1245. X                    putchar ( terminator );
  1246. X                    in_sequence = FALSE;    /* terminates */
  1247. X                    Flush_Bytes ( value );    /* pass data */
  1248. X                }
  1249. X
  1250. X                continue;
  1251. X            }
  1252. X
  1253. X            /*
  1254. X            **  Ok, this is a sequence we want to pay attention to.
  1255. X            **
  1256. X            **  Do_Graphics returns TRUE if we need to pass seq.
  1257. X            **
  1258. X            **  Note:  Do_Graphics modifies the parser vars such
  1259. X            **         as in_sequence.  This is because it may
  1260. X            **         have to output stuff directly.
  1261. X            */
  1262. X
  1263. X            if ( Do_Graphics ( group_char, value, terminator ) )
  1264. X            {
  1265. X                /*
  1266. X                **  If not in sequence, then we output esc
  1267. X                **  otherwise, output the saved terminator.
  1268. X                */
  1269. X
  1270. X                if ( !in_sequence )
  1271. X                {
  1272. X                    in_sequence = TRUE;
  1273. X                    putchar ( ESC );
  1274. X                    putchar ( parameter );
  1275. X                    putchar ( group_char );
  1276. X                } else
  1277. X                {
  1278. X                    putchar ( old_terminator );
  1279. X                }
  1280. X
  1281. X                /* now pass the value */
  1282. X
  1283. X                if ( plus_sign )
  1284. X                    putchar('+');
  1285. X
  1286. X                /*
  1287. X                **  See if there was a non-zero fraction.
  1288. X                */
  1289. X
  1290. X                if ( fvalue != 0.0 )
  1291. X                {
  1292. X                    if ( value < 0 )
  1293. X                    {
  1294. X                        putchar('-');
  1295. X                        value = -value;
  1296. X                    }
  1297. X
  1298. X                    fvalue += value;
  1299. X
  1300. X                    printf("%g", fvalue);
  1301. X
  1302. X                } else if ( scanf_count )
  1303. X                    printf("%0d", value);
  1304. X
  1305. X                /*
  1306. X                **  We save the terminator, because we may
  1307. X                **  need to change it to upper case.
  1308. X                */
  1309. X
  1310. X                old_terminator = terminator;
  1311. X            }
  1312. X
  1313. X        } while ( terminator >= '`' && terminator <= '~' );
  1314. X
  1315. X        /*
  1316. X        ** The oppsite test (above) may be more appropriate.  That is, 
  1317. X        ** !(terminator >= '@' && terminator <= '^').
  1318. X        */
  1319. X        
  1320. X        /*
  1321. X        **  If we were in a sequence, then we must terminate it.
  1322. X        **  If it was lower case, then it must be uppered.
  1323. X        */
  1324. X
  1325. X        if ( in_sequence )
  1326. X        {
  1327. X            putchar ( terminator & 0xdf );        /* a ==> A */
  1328. X            in_sequence = FALSE;
  1329. X        }
  1330. X    }
  1331. X    
  1332. X
  1333. X    /*
  1334. X    **  If the user wants a reset, give him one.
  1335. X    */
  1336. X
  1337. X    if ( reset_seq )
  1338. X    {
  1339. X        putchar ( ESC );
  1340. X        putchar ( 'E' );
  1341. X    }
  1342. X
  1343. X
  1344. X    /*
  1345. X    **  Finished up, so print stats and close output file.
  1346. X    */
  1347. X
  1348. X    fclose(stdout);
  1349. X
  1350. X
  1351. X    if ( verbose )
  1352. X    {
  1353. X        for(j = 0; j < 4; j++)
  1354. X            fprintf(stderr,"Rows in mode %1d: %d\n", j, inuse[j]);
  1355. X        for(j = 0; j < 4; j++)
  1356. X            fprintf(stderr,"Rows out mode %1d: %d\n", j, outuse[j]);
  1357. X    }
  1358. X
  1359. X    exit(0);
  1360. }
  1361. X
  1362. X
  1363. /*
  1364. **  Do_Graphics() takes the graphics escape sequence and performs the
  1365. **  necessary functions.
  1366. **  TRUE is returned if the escape sequence needs to be passed to the output.
  1367. */
  1368. X
  1369. int    Do_Graphics( group, num, terminator )
  1370. int    group, num, terminator;
  1371. {
  1372. X    /*  first look at vW  */
  1373. X
  1374. X    if ( group == 'v' )
  1375. X
  1376. X        if ( terminator != 'W' )
  1377. X            
  1378. X            return ( TRUE );    /* pass it thru */
  1379. X        else
  1380. X        {
  1381. X            if ( !in_sequence )
  1382. X            {
  1383. X                putchar ( ESC );
  1384. X                putchar ( parameter );
  1385. X                putchar ( group );
  1386. X            } else
  1387. X                putchar ( old_terminator );
  1388. X
  1389. X            in_sequence = FALSE;        /* terminating */
  1390. X
  1391. X            printf("%0d", num);
  1392. X            putchar ( terminator );
  1393. X
  1394. X            free_mem();    /* reset memory */
  1395. X
  1396. X            imaging++;
  1397. X
  1398. X            fread(&imdata, MIN(num, 18), 1, stdin);
  1399. X            fwrite(&imdata, MIN(num, 18), 1, stdout);
  1400. X
  1401. X            num -= MIN(num, 18);
  1402. X
  1403. X            /* copy rest of unknown data */
  1404. X
  1405. X            if ( num > 0 )
  1406. X                Flush_Bytes(num);
  1407. X
  1408. X
  1409. X            switch(imdata.pix_mode){
  1410. X                case 0x00:
  1411. X                    rasterwidth = (rpix + 7)/8;
  1412. X                    num_planes = imdata.inx_bits;
  1413. X                    break;
  1414. X                case 0x01:
  1415. X                    rasterwidth = rpix*imdata.inx_bits/8;
  1416. X                    break;
  1417. X                case 0x02:
  1418. X                    rasterwidth = (rpix + 7)/8;
  1419. X                    num_planes =imdata.red + imdata.green +
  1420. X                                imdata.blue;
  1421. X                    break;
  1422. X                case 0x03:
  1423. X                    rasterwidth = (imdata.red +
  1424. X                                   imdata.green +
  1425. X                                   imdata.blue)*rpix/8;
  1426. X                    break;
  1427. X            }
  1428. X
  1429. X            return ( FALSE );
  1430. X        }
  1431. X
  1432. X    /*
  1433. X    **  Now deal with <esc>*r stuff
  1434. X    */
  1435. X
  1436. X    if ( group == 'r' )
  1437. X    {
  1438. X        switch ( terminator )
  1439. X        {
  1440. X            case 'A':
  1441. X            case 'a':
  1442. X
  1443. X                /* Enter graphics mode, enable stripping */
  1444. X
  1445. X                in_graphics = TRUE;
  1446. X
  1447. X                /* if user wants to strip redundant seq */
  1448. X                if ( strip_seq && memflag )
  1449. X                    return( FALSE );
  1450. X
  1451. X                curr_plane=0;
  1452. X                zero_seeds();    /* may allocate mem */
  1453. X                break;
  1454. X
  1455. X            case 'C':
  1456. X            case 'c':
  1457. X
  1458. X                /* Exit graphics, disable stripping */
  1459. X
  1460. X                in_graphics = FALSE;
  1461. X
  1462. X                if ( strip_seq )
  1463. X                    return( FALSE );
  1464. X
  1465. X                inmode = 0;
  1466. X                outmode = 0;
  1467. X
  1468. X                free_mem();
  1469. X                curr_plane=0;
  1470. X                break;
  1471. X
  1472. X            case 'B':
  1473. X            case 'b':
  1474. X
  1475. X                /* Exit graphics, disable stripping */
  1476. X
  1477. X                in_graphics = FALSE;
  1478. X
  1479. X                if ( strip_seq )
  1480. X                    return( FALSE );
  1481. X
  1482. X                if ( deskjet )    /* B resets modes on DJ */
  1483. X                {
  1484. X                    inmode = 0;
  1485. X                    outmode = 0;
  1486. X                }
  1487. X                free_mem();
  1488. X                curr_plane=0;
  1489. X                break;
  1490. X
  1491. X            case 'S':
  1492. X            case 's':
  1493. X
  1494. X                /* free mem in case widths changed */
  1495. X                free_mem();
  1496. X
  1497. X                rpix = num;
  1498. X
  1499. X                if (imaging){
  1500. X                    switch(imdata.pix_mode)
  1501. X                    {
  1502. X                        case 0x00:
  1503. X                            rasterwidth=(rpix+7)/8;
  1504. X                            break;
  1505. X                        case 0x01:
  1506. X                            rasterwidth = 
  1507. X                             rpix*imdata.inx_bits/8;
  1508. X                            break;
  1509. X                        case 0x02:
  1510. X                            rasterwidth=(rpix+7)/8;
  1511. X                            break;
  1512. X                        case 0x03:
  1513. X                            rasterwidth = 
  1514. X                              (imdata.red 
  1515. X                              + imdata.green
  1516. X                              + imdata.blue)*rpix/8;
  1517. X                            break;
  1518. X                    }
  1519. X                } else
  1520. X                    rasterwidth = (num + 7) / 8;
  1521. X                break;
  1522. X
  1523. X            case 'T':
  1524. X            case 't':
  1525. X                break;
  1526. X
  1527. X            case 'U':
  1528. X            case 'u':
  1529. X                curr_plane=0;
  1530. X                free_mem();    /* if ESC*rA came first */
  1531. X
  1532. X                /*  num can be negative */
  1533. X
  1534. X                if ( num < 0 )
  1535. X                    num_planes= -num;
  1536. X                else
  1537. X                    num_planes = num;
  1538. X
  1539. X                imaging = FALSE;    /* goes off */
  1540. X                break;
  1541. X
  1542. X            default:
  1543. X                break;
  1544. X        }
  1545. X
  1546. X        return ( TRUE );        /* pass sequence on */
  1547. X
  1548. X    }    /* group r */
  1549. X
  1550. X    /*
  1551. X    **  Last and final group 'b'.  All the graphics data comes thru here.
  1552. X    */
  1553. X
  1554. X
  1555. X    switch ( terminator )
  1556. X    {
  1557. X           case 'm':
  1558. X           case 'M':
  1559. X            inmode = num;
  1560. X            return ( FALSE );    /* we do NOT pass this */
  1561. X            break;
  1562. X
  1563. X           /*
  1564. X           **  <esc>*b#X is obsolete, but I need to use it.
  1565. X           **  In addition, they will not get passed thru.
  1566. X           */
  1567. X
  1568. X           case 'x':
  1569. X           case 'X':
  1570. X            /*
  1571. X            **  Compute in bytes, rounding down.
  1572. X            */
  1573. X
  1574. X            horiz_offset = num / 8;
  1575. X
  1576. X            if ( horiz_offset < 0 )        /* just in case */
  1577. X                horiz_offset = 0;
  1578. X
  1579. X            if ( strip_offsets || horiz_offset == 0 )
  1580. X                return ( FALSE );    /* do not pass seq */
  1581. X
  1582. X            break;
  1583. X
  1584. X           case 'y':
  1585. X           case 'Y':
  1586. X            /* zero only if allocated */
  1587. X            if ( memflag )
  1588. X                zero_seeds();
  1589. X            break;
  1590. X
  1591. X           case 'W':
  1592. X            if(!memflag)
  1593. X                zero_seeds();        /* get memory */
  1594. X
  1595. X            /* fire up sequence */
  1596. X
  1597. X            if ( !in_sequence )
  1598. X            {
  1599. X                putchar ( ESC );
  1600. X                putchar ( parameter );
  1601. X                putchar ( group );
  1602. X            } else
  1603. X                putchar ( old_terminator );
  1604. X
  1605. X            in_sequence = FALSE;        /* terminating */
  1606. X
  1607. X            /*
  1608. X            **  Check to see if we are expecting another plane.
  1609. X            */
  1610. X
  1611. X            if(curr_plane < num_planes) 
  1612. X            {
  1613. X                /*
  1614. X                **  If the input file does not have all the
  1615. X                **  expected planes  (i.e., <esc>*b0W instead
  1616. X                **  of <esc>*b0V<esc>*b0V<esc>*b0W), then
  1617. X                **  special handling is needed.
  1618. X                */
  1619. X
  1620. X                if( curr_plane + 1 < num_planes )
  1621. X                {
  1622. X                    Process_Gap ( num );
  1623. X
  1624. X                } else        /* don't worry, be happy */
  1625. X
  1626. X                    Process(num, 'W');
  1627. X
  1628. X            } else        /* oops, too many planes of data */
  1629. X
  1630. X                Process_extra(num,'W');   
  1631. X
  1632. X            curr_plane=0;
  1633. X
  1634. X            return ( FALSE );
  1635. X
  1636. X            break;
  1637. X
  1638. X           case 'V':
  1639. X            if(!memflag)
  1640. X                zero_seeds();        /* get memory */
  1641. X            
  1642. X            /*
  1643. X            **  If curr_plane is the last plane, this should
  1644. X            **  be a 'W', not a 'V'.  I could change it,
  1645. X            **  then I would fix Process_extra() to not output
  1646. X            **  anything as the 'W' was already sent.
  1647. X            */
  1648. X
  1649. X            if( curr_plane < num_planes ) 
  1650. X            {
  1651. X                /* fire up sequence */
  1652. X
  1653. X                if ( !in_sequence )
  1654. X                {
  1655. X                    putchar ( ESC );
  1656. X                    putchar ( parameter );
  1657. X                    putchar ( group );
  1658. X                } else
  1659. X                    putchar ( old_terminator );
  1660. X
  1661. X                in_sequence = FALSE;    /* terminating */
  1662. X            
  1663. X
  1664. X                Process(num, 'V');
  1665. X                curr_plane++;
  1666. X            } else
  1667. X                Process_extra(num,'V');
  1668. X
  1669. X            return ( FALSE );
  1670. X
  1671. X            break;
  1672. X
  1673. X        default:
  1674. X            break;
  1675. X    }
  1676. X
  1677. X    return ( TRUE );        /* pass sequence */
  1678. }
  1679. X
  1680. X
  1681. /*
  1682. **  Flush_To_Term() simply passes thru input until a valid terminator
  1683. **  character is found.  This is for unwanted escape sequences.
  1684. */
  1685. X
  1686. Flush_To_Term()
  1687. {
  1688. X    int    c;
  1689. X
  1690. X    do
  1691. X    {
  1692. X        c = getchar();
  1693. X
  1694. X        if ( c == EOF )            /* this is a problem */
  1695. X            return;
  1696. X        
  1697. X        putchar ( c );
  1698. X
  1699. X    } while ( c < '@' || c > '^' );
  1700. }
  1701. X
  1702. X
  1703. /*
  1704. **  Flush_Bytes() simply transfers so many bytes directly from input to output.
  1705. **  This is used to pass thru binary data that we are not interested in so that
  1706. **  it will not confuse the parser.  I.e. downloads.
  1707. */
  1708. X
  1709. Flush_Bytes( num )
  1710. unsigned int    num;
  1711. {
  1712. X    int    bnum;
  1713. X
  1714. X    while ( num > 0 )
  1715. X    {
  1716. X        bnum = MIN ( BUFSIZ, num );
  1717. X
  1718. X        fread( buf, 1, bnum, stdin );
  1719. X
  1720. X        if ( fwrite( buf, 1, bnum, stdout ) < bnum )
  1721. X
  1722. X            /* check for error and exit */
  1723. X
  1724. X            if ( ferror(stdout) )
  1725. X            {
  1726. X                perror("Output error");
  1727. X                exit(-2);
  1728. X            }
  1729. X
  1730. X        num -= bnum;
  1731. X    }
  1732. }
  1733. X
  1734. X
  1735. X
  1736. X
  1737. /*----------------------------------------*/
  1738. X
  1739. /*
  1740. **    Zero_seeds() will allocate and initialize memory.
  1741. **    If memory has already been allocated, then it will just initialize it.
  1742. */
  1743. X
  1744. X
  1745. zero_seeds()
  1746. {
  1747. X    int r;
  1748. X
  1749. X    /* first allocate and init seed_rows for number of planes. */
  1750. X
  1751. X    for ( r = 0; r < num_planes ; r++)
  1752. X    {
  1753. X        if(!memflag)
  1754. X        {
  1755. X            seed_row[r] = (unsigned char *) malloc(rasterwidth);
  1756. X
  1757. X            if ( seed_row[r] == NULL )
  1758. X            {
  1759. X                fprintf(stderr, "Out of memory.\n");
  1760. X                exit(-3);
  1761. X            }
  1762. X        }
  1763. X
  1764. X        /* zero seeds for mode 3 */
  1765. X
  1766. X        memset(seed_row[r], 0, rasterwidth);
  1767. X    }
  1768. X
  1769. X
  1770. X    if(!memflag)
  1771. X    {
  1772. X        new_row = (unsigned char *) malloc(rasterwidth);
  1773. X
  1774. X        if ( new_row == NULL )
  1775. X        {
  1776. X            fprintf(stderr, "Out of memory.\n");
  1777. X            exit(-3);
  1778. X        }
  1779. X
  1780. X        for(r=0; r<MAXMODES; r++)
  1781. X        {
  1782. X            /* 2 * width is needed for modes 1, 2 and 3 */
  1783. X
  1784. X            out_row[r] = (unsigned char *) malloc(2 * rasterwidth);
  1785. X
  1786. X            if ( out_row[r] == NULL )
  1787. X            {
  1788. X                fprintf(stderr, "Out of memory.\n");
  1789. X                exit(-3);
  1790. X            }
  1791. X        }
  1792. X
  1793. X    }
  1794. X
  1795. X    memset(new_row, 0, rasterwidth);
  1796. X
  1797. X    memflag = TRUE;            /* memory is in place */
  1798. }
  1799. X
  1800. X
  1801. /* this routine if for incomplete transfers of data */
  1802. X
  1803. zero_upper(plane)
  1804. int    plane;
  1805. {
  1806. X    int i;
  1807. X
  1808. X    /* assume memory already present */
  1809. X
  1810. X    for ( i = plane; i < num_planes; i++)
  1811. X        memset(seed_row[i], 0, rasterwidth);
  1812. }
  1813. X
  1814. X
  1815. /*
  1816. **  Process() manages the decompression and re-compression of data.
  1817. */
  1818. X
  1819. Process(inbytes, terminator)
  1820. int inbytes, terminator;
  1821. {
  1822. X
  1823. X    int insize;
  1824. X    int minmode = 0;
  1825. X
  1826. X    inuse[inmode]++;
  1827. X
  1828. X    /*
  1829. X    **  Clamp horizontal offset to the rasterwidth for safety.
  1830. X    */
  1831. X
  1832. X    if ( horiz_offset > rasterwidth )
  1833. X
  1834. X        horiz_offset = rasterwidth;
  1835. X
  1836. X    /*
  1837. X    **  Zero out horiz_offset bytes in new_row.
  1838. X    */
  1839. X
  1840. X    if ( horiz_offset )
  1841. X
  1842. X        memset ( new_row, 0, horiz_offset );
  1843. X
  1844. X
  1845. X    switch ( inmode ) {
  1846. X
  1847. X    case 0:
  1848. X        if ( !widthwarning && inbytes > rasterwidth )
  1849. X        {
  1850. X            /* This is likely to result in data truncation. */
  1851. X            widthwarning = TRUE;
  1852. X            fprintf(stderr,"Warning: Input pixel width exceeds expected width.\n");
  1853. X        }
  1854. X
  1855. X        insize = Mode_0_Graphics( inbytes, rasterwidth - horiz_offset,
  1856. X                new_row + horiz_offset);
  1857. X        break;
  1858. X    case 1:
  1859. X        insize = Mode_1_Graphics( inbytes, rasterwidth - horiz_offset,
  1860. X                new_row + horiz_offset);
  1861. X        break;
  1862. X    case 2:
  1863. X        insize = Mode_2_Graphics( inbytes, rasterwidth - horiz_offset,
  1864. X                new_row + horiz_offset);
  1865. X        break;
  1866. X    case 3:
  1867. X        memcpy(new_row, seed_row[curr_plane], rasterwidth);
  1868. X
  1869. X        if ( horiz_offset )
  1870. X            memset ( new_row, 0, MIN( horiz_offset, rasterwidth ) );
  1871. X
  1872. X        insize = Mode_3_Graphics(inbytes, rasterwidth - horiz_offset,
  1873. X                new_row + horiz_offset);
  1874. X        break;
  1875. X
  1876. X    default:        /* unknown mode? */
  1877. X
  1878. X        /*  Don't know what to do about seed rows, pass stuff thru */
  1879. X
  1880. X        fprintf(stderr, "%s: Unsupported compression mode %d.\n",
  1881. X            progname, inmode );
  1882. X
  1883. X        ChangeMode(inmode);    /* go to that mode */
  1884. X
  1885. X        /* <esc>*b has already been output */
  1886. X
  1887. X        printf("%1d%c", inbytes, terminator);
  1888. X
  1889. X        Flush_Bytes( inbytes );
  1890. X
  1891. X        firstrow = TRUE;        /* pop it out of mode 3 */
  1892. X
  1893. X        /*  Go ahead and clear the seed rows if present  */
  1894. X        if ( memflag )
  1895. X            zero_seeds();
  1896. X
  1897. X        return;
  1898. X
  1899. X    }
  1900. X
  1901. X    /*
  1902. X    **  We need to account for the horizontal offset, but if strip_offsets
  1903. X    **  is on, then assume that zero is white.
  1904. X    */
  1905. X
  1906. X    if ( strip_offsets )
  1907. X        horiz_offset = 0;
  1908. X
  1909. X
  1910. X    if ( mode0 )
  1911. X        /* actually, this is redundant since new_row is mode 0 */
  1912. X        out_size[0] = Output_0( new_row + horiz_offset, out_row[0], 
  1913. X                rasterwidth - horiz_offset );
  1914. X    else
  1915. X        out_size[0] = MAXBYTES+1;
  1916. X
  1917. X    if ( mode1 )
  1918. X        out_size[1] = Output_1( new_row + horiz_offset, out_row[1], 
  1919. X                rasterwidth - horiz_offset );
  1920. X    else
  1921. X        out_size[1] = MAXBYTES+1;
  1922. X
  1923. X    if ( mode2 )
  1924. X        out_size[2] = Output_2( new_row + horiz_offset, out_row[2], 
  1925. X                rasterwidth - horiz_offset );
  1926. X    else
  1927. X        out_size[2] = MAXBYTES+1;
  1928. X
  1929. X    if ( mode3 )
  1930. X        out_size[3] = Output_3( seed_row[curr_plane] + horiz_offset, 
  1931. X                new_row + horiz_offset, out_row[3], 
  1932. X                rasterwidth - horiz_offset );
  1933. X    else
  1934. X        out_size[3] = MAXBYTES+1;
  1935. X    
  1936. X
  1937. X    /*
  1938. X    **  Obsolete comment:
  1939. X    **
  1940. X    **  Now determine which mode will give the best output.  Note that it
  1941. X    **  takes 5 bytes to change modes, so we penalize all modes that are
  1942. X    **  not the current output by 5 bytes.  This is to discourage changing
  1943. X    **  unless the benifit is worth it.  The exception to this rule is
  1944. X    **  mode 3.  We want to encourage going to mode 3 because of the seed
  1945. X    **  row behaviour.  That is, if we have a simple picture that does
  1946. X    **  not change much, and say each of the sizes for modes 1 and 2 always
  1947. X    **  comes out to 4 bytes of data, then if we add 5 to mode 3 each time,
  1948. X    **  it would never get selected.  But, we remove the penalty, and if
  1949. X    **  mode 3 is selected (0 bytes of data needed for mode 3), then each
  1950. X    **  succesive row only needs 0 bytes of data.  For a 300 dpi A size
  1951. X    **  picture with 3 data planes, this could be a savings of 37k bytes.
  1952. X    */
  1953. X
  1954. X    /*
  1955. X    **  With the new parser, the output to change modes is now only
  1956. X    **  2 bytes, since it gets combined with the *b#W sequence.
  1957. X    **  So, I decided to ignore the switching penalty.
  1958. X    */
  1959. X
  1960. X    /*
  1961. X    **  Due to a possible bug in PaintJet XL, don't allow mode 3 to be
  1962. X    **  selected for the first row of output.  But do allow it if the
  1963. X    **  user has no other mode selected.
  1964. X    */
  1965. X
  1966. X    if ( firstrow && (mode0 || mode1 || mode2) )
  1967. X    {
  1968. X        out_size[3] = MAXBYTES+1;    /* disable mode 3 for now */
  1969. X
  1970. X        if ( terminator == 'W' )    /* last plane? */
  1971. X            firstrow = FALSE;    /* no longer first row */
  1972. X    }
  1973. X
  1974. X
  1975. X    minmode = 3;
  1976. X
  1977. X    if ( out_size[2] < out_size[minmode] )
  1978. X        minmode = 2;
  1979. X
  1980. X    if ( out_size[1] < out_size[minmode] )
  1981. X        minmode = 1;
  1982. X
  1983. X    if ( out_size[0] < out_size[minmode] )
  1984. X        minmode = 0;
  1985. X
  1986. X
  1987. X                    /* I may remove this sometime */
  1988. X    if ( minmode != outmode )
  1989. X        if ( out_size[minmode] == out_size[outmode] )
  1990. X            minmode = outmode;
  1991. X
  1992. X
  1993. X    outuse[minmode]++;
  1994. X
  1995. X    if ( outmode != minmode )
  1996. X        ChangeMode( minmode );
  1997. X    
  1998. X    /* <esc>*b has already been output */
  1999. X
  2000. X    printf("%1d%c", out_size[minmode], terminator);
  2001. X
  2002. X    if ( fwrite( out_row[minmode], 1, out_size[minmode], stdout) < 
  2003. X                            out_size[minmode] )
  2004. X
  2005. X        /* check for error and exit */
  2006. X
  2007. X        if ( ferror(stdout) )
  2008. X        {
  2009. X            perror("Output error");
  2010. X            exit(-2);
  2011. X        }
  2012. X
  2013. X
  2014. X    memcpy(seed_row[curr_plane], new_row, rasterwidth);
  2015. X
  2016. X    /*
  2017. X    **  Now clear horizontal offset for next plane.
  2018. X    */
  2019. X
  2020. X    horiz_offset = 0;
  2021. X
  2022. }
  2023. X
  2024. X
  2025. /*
  2026. **  Process_Gap() is to handle the case where less planes are sent for a
  2027. **  row than we are expecting.  For example, if we are expecting 3 planes
  2028. **  per row, and the driver decides to take a short cut for blank areas and
  2029. **  send only the final 'W'  ( <esc>*b0W instead of the complete <esc>*b0V
  2030. **  <esc>*b0V <esc>*b0W), then we have to do some special handling for mode
  2031. **  3 seed rows.
  2032. **
  2033. **  The terminator is not needed as a parameter since we know that it must
  2034. **  be 'W' to get into this routine.
  2035. */
  2036. X
  2037. Process_Gap(bytes)
  2038. int    bytes;
  2039. {
  2040. X    char    save0, save1, save2, save3;
  2041. X
  2042. X    /*
  2043. X    **  If the input file does not have all the expected planes  
  2044. X    **  (i.e., <esc>*b0W instead **  of <esc>*b0V<esc>*b0V<esc>*b0W), 
  2045. X    **  then special handling is needed.
  2046. X    **
  2047. X    **  4 cases are handled:
  2048. X    **
  2049. X    **  input mode  output mode   extra action
  2050. X    **  ----------  -----------   ------------
  2051. X    **
  2052. X    **    non-3       non-3       zero seeds
  2053. X    **
  2054. X    **      3           3         do nothing
  2055. X    **
  2056. X    **    non-3         3         zero seeds & extra output
  2057. X    **
  2058. X    **      3         non-3       extra output
  2059. X    **
  2060. X    **  Note:  We don't know what the output
  2061. X    **  mode will be before we call Process(),
  2062. X    **  so we must force the modes.
  2063. X    */
  2064. X
  2065. X    /*
  2066. X    **  Save output modes in case we need to manipulate them.
  2067. X    */
  2068. X
  2069. X    save0 = mode0;
  2070. X    save1 = mode1;
  2071. X    save2 = mode2;
  2072. X    save3 = mode3;
  2073. X
  2074. X
  2075. X    if ( inmode != 3 )
  2076. X    {
  2077. X        /*
  2078. X        **  Force output to non-3
  2079. X        **  to do as little as possible.
  2080. X        */
  2081. X
  2082. X        if ( mode0 || mode1 || mode2 )
  2083. X        {
  2084. X            mode3 = FALSE;
  2085. X
  2086. X            Process(bytes, 'W');
  2087. X
  2088. X            mode3 = save3;        /* restore mode 3 */
  2089. X
  2090. X            zero_upper( curr_plane + 1);
  2091. X
  2092. X        } else    /* mode 3 is only one allowed for output */
  2093. X        {
  2094. X            /*
  2095. X            **  We must output more info.
  2096. X            */
  2097. X
  2098. X            Process( bytes, 'V' );    /* convert to plane */
  2099. X
  2100. X            curr_plane++;
  2101. X
  2102. X            while ( curr_plane < num_planes )
  2103. X            {
  2104. X                /*
  2105. X                **  Restart graphics data sequence.
  2106. X                */
  2107. X
  2108. X                putchar ( ESC );
  2109. X                putchar ( '*' );
  2110. X                putchar ( 'b' );
  2111. X
  2112. X                /*
  2113. X                **  Call Process() with 0 bytes instead
  2114. X                **  of just doing output because we
  2115. X                **  need Process() to zero the appropriate
  2116. X                **  seed rows, and to use mode 3 to clear
  2117. X                **  the seed rows in the output (printer).
  2118. X                */
  2119. X
  2120. X                if ( curr_plane + 1 == num_planes )
  2121. X
  2122. X                    Process(0, 'W');    /* last plane */
  2123. X                else
  2124. X                    Process(0, 'V');
  2125. X
  2126. X                curr_plane++;
  2127. X            }
  2128. X        }
  2129. X    } else        /* inmode == 3 */
  2130. X    {
  2131. X        /*
  2132. X        **  Inmode is 3, so make outmode be 3 so we can do nothing.
  2133. X        */
  2134. X
  2135. X        if ( mode3 )            /* is mode 3 allowed? */
  2136. X        {
  2137. X            mode0 =
  2138. X            mode1 =
  2139. X            mode2 = FALSE;
  2140. X
  2141. X            Process(bytes, 'W');
  2142. X
  2143. X            mode0 = save0;        /* restore modes */
  2144. X            mode1 = save1;
  2145. X            mode2 = save2;
  2146. X
  2147. X        } else                /* ooops, no mode 3 */
  2148. X        {
  2149. X            /*
  2150. X            **  We must output more info.
  2151. X            */
  2152. X
  2153. X            Process( bytes, 'V' );    /* convert to plane */
  2154. X
  2155. X            curr_plane++;
  2156. X
  2157. X            while ( curr_plane < num_planes )
  2158. X            {
  2159. X                /*
  2160. X                **  Restart graphics data sequence.
  2161. X                */
  2162. X
  2163. X                putchar ( ESC );
  2164. X                putchar ( '*' );
  2165. X                putchar ( 'b' );
  2166. X
  2167. X                /*
  2168. X                **  Call Process() with 0 bytes instead
  2169. X                **  of just doing output because we
  2170. X                **  need Process() to use the seed rows
  2171. X                **  to create non-mode3 data.
  2172. X                */
  2173. X
  2174. X                if ( curr_plane + 1 == num_planes )
  2175. X
  2176. X                    Process(0, 'W');    /* last plane */
  2177. X                else
  2178. X                    Process(0, 'V');
  2179. X
  2180. X                curr_plane++;
  2181. X            }
  2182. X        }
  2183. X    }
  2184. }
  2185. X
  2186. X
  2187. /*
  2188. **  Process_extra() is to handle the extra planes.  That is, for PaintJets,
  2189. **  when sending 3 planes of data using <esc>*b#V, many drivers send a
  2190. **  fourth plane as <esc>*b0W to terminate the row, instead of the recommended
  2191. **  'W' as the 3rd plane.  This routine handles the extra without disturbing
  2192. **  the mode 3 seed rows.
  2193. **
  2194. **  In the future, this routine could be used to strip out the 4th plane.
  2195. */
  2196. X
  2197. Process_extra(bytes, terminator)
  2198. int    bytes;
  2199. char    terminator;
  2200. {
  2201. X    int  i;
  2202. X
  2203. X    /* toss any excess data */
  2204. X
  2205. X    for(i = 0; i < bytes; i++)
  2206. X       getchar();
  2207. X
  2208. X    /* last plane? force move down to next row */
  2209. X
  2210. X    if(terminator == 'W')
  2211. X    {
  2212. X        /* <esc>*b has already been output */
  2213. X        printf("0W");
  2214. X
  2215. X        firstrow = FALSE;        /* not on first row anymore */
  2216. X
  2217. X    }
  2218. X
  2219. }
  2220. X
  2221. /*
  2222. **  ChangeMode() simply outputs the sequence to change compression modes.
  2223. */
  2224. X
  2225. ChangeMode(newmode)
  2226. int newmode;
  2227. {
  2228. X    /*
  2229. X    **  <esc>*b have already been output.
  2230. X    **  terminator is 'm' instead of 'M' since will be followed by 'W'
  2231. X    */
  2232. X    printf("%1dm", newmode);
  2233. X    outmode = newmode;
  2234. }
  2235. X
  2236. X
  2237. /*-----------------------------------------------------------------------*\
  2238. X |                                                                       |
  2239. X |  Function Name: Mode_0_Graphics                                       |
  2240. X |                                                                       |
  2241. X |  Description:                                                         |
  2242. X |                                                                       |
  2243. X |  This is the routine that handles a Mode 0 graphics block transfer    |
  2244. X |  to the Formatter Module.                                             |
  2245. X |                                                                       |
  2246. \*-----------------------------------------------------------------------*/
  2247. X
  2248. /* FUNCTION */
  2249. X
  2250. Mode_0_Graphics(input_bytes, output_bytes, address)
  2251. X
  2252. unsigned int
  2253. X   input_bytes,                 /* Count of bytes to be read. */
  2254. X   output_bytes;                /* Count of bytes to be stored. */
  2255. X
  2256. unsigned char
  2257. X   *address;                    /* Pointer to where to store bytes. */
  2258. X
  2259. {
  2260. X   /* LOCAL VARIABLES */
  2261. X
  2262. X   unsigned char
  2263. X      *store_ptr;               /* Pointer to where to store the byte. */
  2264. X
  2265. X   unsigned int
  2266. X      read_bytes,               /* Local copy of input_bytes. */
  2267. X      write_bytes;              /* Local copy of output_bytes. */
  2268. X
  2269. X   /* CODE */
  2270. X
  2271. X   /* Initialize the local variables. */
  2272. X
  2273. X   read_bytes = input_bytes;
  2274. X   write_bytes = output_bytes;
  2275. X   store_ptr = address;
  2276. X   
  2277. X
  2278. X   /* transfer the lesser of available bytes or available room */
  2279. X
  2280. X     Transfer_Block( MIN(write_bytes,read_bytes), store_ptr);
  2281. X
  2282. X   /* now zero fill or throw excess data away */
  2283. X
  2284. X   if ( read_bytes > write_bytes )
  2285. X      Discard_Block(read_bytes - write_bytes);        /* throw excess */
  2286. X   else {
  2287. X      store_ptr += read_bytes;                /* adjust pointer */
  2288. X      write_bytes -= read_bytes;            /* zero fill count */
  2289. X
  2290. X      memset(store_ptr, 0, write_bytes);
  2291. X   }
  2292. X
  2293. X   return ( input_bytes );
  2294. }
  2295. X
  2296. X
  2297. /*-----------------------------------------------------------------------*\
  2298. X |                                                                       |
  2299. X |  Function Name: Mode_1_Graphics                                       |
  2300. X |                                                                       |
  2301. X |  Description:                                                         |
  2302. X |                                                                       |
  2303. X |  This is the routine that handles a Mode 1 graphics block transfer    |
  2304. X |  to the Formatter Module.  Mode 1 graphics is a compacted mode.       |
  2305. X |  The data in Mode 1 is in pairs.  The first byte is a replicate       |
  2306. X |  count and the second byte is the data.  The data byte is stored      |
  2307. X |  then replicated the replicate count.  Therefore a replicate count    |
  2308. X |  of 0 means the data byte is stored once.  The input byte count       |
  2309. X |  must be an even amount for the data to be in byte pairs.             |
  2310. X |                                                                       |
  2311. \*-----------------------------------------------------------------------*/
  2312. X
  2313. /* FUNCTION */
  2314. X
  2315. Mode_1_Graphics(input_bytes, output_bytes, address)
  2316. X
  2317. unsigned int
  2318. X   input_bytes,                 /* Count of bytes to be read. */
  2319. X   output_bytes;                /* Count of bytes to be stored. */
  2320. X
  2321. unsigned char
  2322. X   *address;                    /* Pointer to where to store bytes. */
  2323. X
  2324. {
  2325. X   /* LOCAL VARIABLES */
  2326. X
  2327. X   unsigned char
  2328. X      *store_ptr,               /* Pointer to where to store the byte. */
  2329. SHAR_EOF
  2330. true || echo 'restore of pclcomp.c failed'
  2331. fi
  2332. echo 'End of  part 1'
  2333. echo 'File pclcomp.c is continued in part 2'
  2334. echo 2 > _shar_seq_.tmp
  2335. exit 0
  2336. exit 0 # Just in case...
  2337. -- 
  2338. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  2339. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  2340. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  2341. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  2342.